#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QStringList>
#include <QSerialPortInfo>
#include <QSerialPort>
#include <QDebug>
#include <QTimer>
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , modbusDevice(nullptr)
    , serialThread(new QThread(this))  // 创建线程
    , serialWorker(new SerialSearchWorker()
    ) // 创建工作对象
{
    ui->setupUi(this);
    timer = new QTimer(this);
    timer->setInterval(1000); // 每1秒触发一次
    timer_inputreg = new QTimer(this);
    timer_inputreg->setInterval(1000); // 每1秒触发一次
    connect(timer, &QTimer::timeout, this, &MainWindow::cfg_onTimeout);
    connect(timer_inputreg, &QTimer::timeout, this, &MainWindow::env_onTimeout);
    connect(serialWorker, &SerialSearchWorker::sendReadRequest, this, &MainWindow::sendReadRequest);

    // 初始化波特率下拉框
    QStringList list = {"4800", "9600", "115200"};
    ui->baud_cbx->addItems(list);
    ui->baud_cbx->setCurrentText("9600");
    // 将工作对象移到线程
    serialWorker->moveToThread(serialThread);

    // 连接信号槽
    connect(ui->searchPort_btn, &QPushButton::clicked, this, &MainWindow::freshSerialPortCombox); // 点击搜索按钮
    connect(ui->open_serial_btn, &QPushButton::clicked, this, &MainWindow::connectModbus);
    connect(serialWorker, &SerialSearchWorker::portsFound, this, &MainWindow::updateSerialPortList); // 工作线程发信号更新列表
    connect(serialWorker, &SerialSearchWorker::sendReadInputRegRqe, this, &MainWindow::sendReadRequest_input); // 工作线程发信号更新列表
    connect(ui->test_btn, &QPushButton::clicked, this, &MainWindow::sendReadRequest_input);
    // 线程启动
    serialThread->start();
    connect(ui->tabWidget, &QTabWidget::currentChanged, this, &MainWindow::onTabChanged);



    InitModbus();
}

MainWindow::~MainWindow()
{
    // 停止线程并释放资源
    serialThread->quit();
    serialThread->wait();
    delete serialWorker;
    delete ui;
}

void MainWindow::freshSerialPortCombox()
{
    // 在工作线程中执行串口搜索
    QMetaObject::invokeMethod(serialWorker, "searchSerialPorts", Qt::QueuedConnection);
}
void MainWindow::cfg_onTimeout()
{
    // 每次定时器触发时，将任务添加到工作线程的任务队列
    QMetaObject::invokeMethod(serialWorker, "processTask", Qt::QueuedConnection);
}
void MainWindow::env_onTimeout()
{
    // 每次定时器触发时，将任务添加到工作线程的任务队列
    QMetaObject::invokeMethod(serialWorker, "inputreadTask", Qt::QueuedConnection);
}
void MainWindow::updateSerialPortList(QStringList portList)
{
    // 更新串口下拉框
    ui->serialPort_cbx->clear();
    ui->serialPort_cbx->addItems(portList);
}

void MainWindow::InitModbus()
{
    // 初始化 Modbus 设备
    if (modbusDevice) {
        modbusDevice->disconnectDevice();
        delete modbusDevice;
        modbusDevice = nullptr;
    }

    modbusDevice = new QModbusRtuSerialMaster(this);
}
void MainWindow::connectModbus()
{
    // 如果已经连接了，就断开连接
    if (modbusDevice && modbusDevice->state() == QModbusDevice::ConnectedState) {
        disconnnectModbus();  // 断开连接
        return ;
    }
    else {
        // 否则，建立连接
        if (!modbusDevice) {
            // 如果modbusDevice为空，创建一个新的设备
            modbusDevice = new QModbusRtuSerialMaster(this);
        }

        modbusDevice->setConnectionParameter(QModbusDevice::SerialPortNameParameter, ui->serialPort_cbx->currentText());
        modbusDevice->setConnectionParameter(QModbusDevice::SerialParityParameter, 0);
        modbusDevice->setConnectionParameter(QModbusDevice::SerialBaudRateParameter, ui->baud_cbx->currentText());
        modbusDevice->setConnectionParameter(QModbusDevice::SerialDataBitsParameter, 8);
        modbusDevice->setConnectionParameter(QModbusDevice::SerialStopBitsParameter, 1);

        // 尝试连接设备
        if (modbusDevice->connectDevice()) {
            ui->open_serial_btn->setText("断开连接");
            qDebug() << "连接成功";
        } else {
            ui->open_serial_btn->setText("建立连接");
            qDebug() << "连接失败";
        }
    }
}


void MainWindow::onTabChanged(int index)
{
    qDebug() << "Tab changed, index: " << index;

    // 判断 Modbus 设备是否连接
    if (modbusDevice && modbusDevice->state() == QModbusDevice::ConnectedState) {
        qDebug() << "Modbus 设备已连接";
    } else {
        qDebug() << "Modbus 设备未连接";
    }
    if (index == 0) {
        if (modbusDevice && modbusDevice->state() == QModbusDevice::ConnectedState) {
            if (!timer_inputreg->isActive()) {
                timer_inputreg->start();
            }
        } else {
            qDebug() << "无法启动定时器：Modbus设备未连接";
        }return;
    } else {
        // 切换到其他 tab 时，停止定时器
        if (timer_inputreg->isActive()) {
            timer_inputreg->stop();
        }

    }
    // 如果切换到第二个tab时，且 Modbus 设备已连接，启动定时器
    if (index == 1) {
        if (modbusDevice && modbusDevice->state() == QModbusDevice::ConnectedState) {
            if (!timer->isActive()) {
                timer->start();
            }
        } else {
            qDebug() << "无法启动定时器：Modbus设备未连接";
        }return;
    } else {
        // 切换到其他 tab 时，停止定时器
        if (timer->isActive()) {
            timer->stop();
        }
    }

   // qDebug() << "Tab index: " << index;
}

void MainWindow::disconnnectModbus()
{
    // 如果modbus设备有效并且连接成功
    if (modbusDevice && modbusDevice->state() == QModbusDevice::ConnectedState) {
        // 断开连接
        modbusDevice->disconnectDevice();
        qDebug() << "Modbus设备已断开连接";

        // 更新按钮文本
        ui->open_serial_btn->setText("建立连接");

        // 这里可以进一步添加串口关闭的操作，如果需要的话
        // 对于 QModbusRtuSerialMaster 对象来说，disconnectDevice 已经关闭了串口，因此不需要额外的操作。
    }
}

void MainWindow::sendReadRequest()
{
    if (!modbusDevice)
    {
        qDebug() << "Modbus设备未初始化";
        return;
    }

    if (modbusDevice->state() != QModbusDevice::ConnectedState)
    {
        qDebug() << "Modbus设备未连接";
        return;
    }

    // 设置 Modbus 地址和请求类型
    int serverAddress = 1; // 从站地址，取决于你的设备
    QModbusDataUnit readUnit(QModbusDataUnit::HoldingRegisters, 0, 12); // 读取寄存器地址 0，读取 10 个寄存器

    // 发送读请求
    if (auto *reply = modbusDevice->sendReadRequest(readUnit, serverAddress))
    {
        if (!reply->isFinished())
        {
            connect(reply, &QModbusReply::finished, this, &MainWindow::handleReadReply);
        }
        else
        {
            // 如果发送失败，则立即删除 reply
            delete reply;
        }
    }
    else
    {
        qDebug() << "发送读请求失败：" << modbusDevice->errorString();
    }
}
void MainWindow::handleReadReply()
{
    auto reply = qobject_cast<QModbusReply *>(sender());
    if (!reply)
        return;

    if (reply->error() == QModbusDevice::NoError)
    {
        // 处理成功的 Modbus 数据
        const QModbusDataUnit unit = reply->result();


       ui->cfg_regriTemp->setText(QString::number(unit.value(0)>32767 ? unit.value(0) - 65536 : unit.value(0)));
       ui->cfg_tempRetdiff->setText(QString::number(unit.value(1)>32767 ? unit.value(1) - 65536 : unit.value(1)));
       ui->cfg_compressDelay->setText(QString::number(unit.value(2)>32767 ? unit.value(2) - 65536 : unit.value(2)));
       ui->cfg_forceRegri->setText(QString::number(unit.value(3)>32767 ? unit.value(3) - 65536 : unit.value(3)));
       ui->cfg_tempCalibrate->setText(QString::number(unit.value(4)>32767 ? unit.value(4) - 65536 : unit.value(4)));
       ui->cfg_maxtemp->setText(QString::number(unit.value(5)>32767 ? unit.value(5) - 65536 : unit.value(5)));
       ui->cfg_mintemp->setText(QString::number(unit.value(6)>32767 ? unit.value(6) - 65536 : unit.value(6)));
       ui->cfg_heattingTemp->setText(QString::number(unit.value(7)>32767 ? unit.value(7) - 65536 : unit.value(7)));
       ui->cfg_warning_lowTemp->setText(QString::number(unit.value(8)>32767 ? unit.value(8) - 65536 : unit.value(8)));
       ui->cfg_warning_highTemp->setText(QString::number(unit.value(9)>32767 ? unit.value(9) - 65536 : unit.value(9)));
       ui->cfg_relayouput->setText(QString::number(unit.value(10)>32767 ? unit.value(10) - 65536 : unit.value(10)));
       ui->cfg_slaveaddr->setText(QString::number(unit.value(11)>32767 ? unit.value(11) - 65536 : unit.value(11)));


    }
    else
    {
        qDebug() << "Modbus 错误：" << reply->errorString();
    }

    reply->deleteLater(); // 删除 reply 避免内存泄漏
}
void MainWindow::sendWriteRequest()
{
    if (!modbusDevice)
    {
        qDebug() << "Modbus设备未初始化";
        return;
    }

    if (modbusDevice->state() != QModbusDevice::ConnectedState)
    {
        qDebug() << "Modbus设备未连接";
        return;
    }

    // 设置 Modbus 地址和请求类型
    int serverAddress = 1; // 从站地址
    QModbusDataUnit writeUnit(QModbusDataUnit::HoldingRegisters, 12, 1); // 写寄存器地址 0，写 1 个寄存器
    writeUnit.setValue(0, ui->simulate_temp_text->text().toInt()); // 设置寄存器值为 12345

    // 发送写请求
    if (auto *reply = modbusDevice->sendWriteRequest(writeUnit, serverAddress))
    {
        if (!reply->isFinished())
        {
            connect(reply, &QModbusReply::finished, this, &MainWindow::handleWriteReply);
        }
        else
        {
            delete reply;
        }
    }
    else
    {
        qDebug() << "发送写请求失败：" << modbusDevice->errorString();
    }
}
void MainWindow::handleWriteReply()
{
    auto reply = qobject_cast<QModbusReply *>(sender());
    if (!reply)
        return;

    if (reply->error() == QModbusDevice::NoError)
    {
        qDebug() << "写请求成功";
    }
    else
    {
        qDebug() << "Modbus 写请求错误：" << reply->errorString();
    }

    reply->deleteLater(); // 删除 reply 避免内存泄漏
}
void MainWindow::sendReadRequest_input()
{
    if (!modbusDevice)
    {
        qDebug() << "Modbus设备未初始化";
        return;
    }

    if (modbusDevice->state() != QModbusDevice::ConnectedState)
    {
        qDebug() << "Modbus设备未连接";
        return;
    }

    // 设置 Modbus 地址和请求类型
    int serverAddress = 1; // 从站地址，取决于你的设备
    QModbusDataUnit readUnit(QModbusDataUnit::InputRegisters,14, 12); // 读取寄存器地址 0，读取 10 个寄存器

    // 发送读请求
    if (auto *reply = modbusDevice->sendReadRequest(readUnit, serverAddress))
    {
        if (!reply->isFinished())
        {
            connect(reply, &QModbusReply::finished, this, &MainWindow::handleReadReply_input);
        }
        else
        {
            // 如果发送失败，则立即删除 reply
            delete reply;
        }
    }
    else
    {
        qDebug() << "发送读请求失败：" << modbusDevice->errorString();
    }
}
void MainWindow::handleReadReply_input()
{
    auto reply = qobject_cast<QModbusReply *>(sender());
    if (!reply)
        return;

    if (reply->error() == QModbusDevice::NoError)
    {
        // 处理成功的 Modbus 数据
        const QModbusDataUnit unit = reply->result();
        //ui->cfg_regriTemp->setText(QString::number(unit.value(0)>32767 ? unit.value(0) - 65536 : unit.value(0)));
        ui->breakdown_shortcircuit_label->setText(QString::number(unit.value(1)>32767 ? unit.value(1) - 65536 : unit.value(1)));
        ui->breakdown_waterfull_label->setText(QString::number(unit.value(2)>32767 ? unit.value(2) - 65536 : unit.value(2)));
        ui->breakdown_beyondtemp_label->setText(QString::number(unit.value(3)>32767 ? unit.value(3) - 65536 : unit.value(3)));
        ui->breakdown_downtemp_label->setText(QString::number(unit.value(4)>32767 ? unit.value(4) - 65536 : unit.value(4)));
        ui->warn_highltemp_label->setText(QString::number(unit.value(5)>32767 ? unit.value(5) - 65536 : unit.value(5)));
        ui->warn_lowltemp_label->setText(QString::number(unit.value(6)>32767 ? unit.value(6) - 65536 : unit.value(6)));
        ui->regri_output_label->setText(QString::number(unit.value(7)>32767 ? unit.value(7) - 65536 : unit.value(7)));
        ui->heating_output_label->setText(QString::number(unit.value(8)>32767 ? unit.value(8) - 65536 : unit.value(8)));
        ui->force_regri_label->setText(QString::number(unit.value(9)>32767 ? unit.value(9) - 65536 : unit.value(9)));
        ui->real_temp_label->setText(QString::number(unit.value(10)>32767 ? unit.value(10) - 65536 : unit.value(10)));
    }
    else
    {
        qDebug() << "Modbus 错误：" << reply->errorString();
    }

    reply->deleteLater(); // 删除 reply 避免内存泄漏
}

void MainWindow::on_simulate_temp_btn_clicked()
{
    sendWriteRequest();
}
